package com.lagou.client;


import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class ZkServerGeter {
//    private static List<String> names = new ArrayList<>();

    private static ConcurrentHashMap<String,String> paths = new ConcurrentHashMap<String,String>();

    public static void getZkServer() throws InterruptedException {


        /*
            创建一个zkclient实例就可以完成连接，完成会话的创建
            serverString : 服务器连接地址

            注意：zkClient通过对zookeeperAPI内部封装，将这个异步创建会话的过程同步化了..
         */

        ZkClient zkClient = new ZkClient("127.0.0.1:2181");
        System.out.println("会话被创建了..");

        // 判断节点是否存在
        String server1Path = "/zkServer1-Ep";
        String server2Path = "/zkServer2-Ep";
        boolean exists1 = zkClient.exists(server1Path);
        boolean exists2 = zkClient.exists(server2Path);

        if(!exists1){
            // 创建临时节点
            System.out.println("生产者1未上线");
        }
        if(!exists2){
            // 创建临时节点
            System.out.println("生产者2未上线");
        }

        if (exists1){
            Object o1 = zkClient.readData(server1Path);
            System.out.println("建立与服务器1的连接"+o1);
            paths.put(server1Path,o1.toString());
//            names.add(server1Path);
        }


        // 读取节点内容

        if (exists2){
            Object o2 = zkClient.readData(server2Path);
            System.out.println("建立与服务器2的连接"+o2);
            paths.put(server2Path,o2.toString());
            //names.add(server2Path);
        }

        // 注册服务器节点1的监听
        zkClient.subscribeDataChanges(server1Path, new IZkDataListener() {

            /*
                当节点数据内容发生变化时，执行的回调方法
                s: path
                o: 变化后的节点内容
             */
            public void handleDataChange(String s, Object o) throws Exception {
                System.out.println(s+"服务器节点1内容被更新，更新的内容"+o);
                paths.put(s,o.toString());
            }

            /*
                当节点被删除时，会执行的回调方法
                s : path
             */
            public void handleDataDeleted(String s) throws Exception {
                System.out.println(s+"服务器节点1下线，断开服务器连接");
                paths.remove(s);

            }
        });
        // 注册服务器节点2的监听

        zkClient.subscribeDataChanges(server2Path, new IZkDataListener() {

            /*
                当节点数据内容发生变化时，执行的回调方法
                s: path
                o: 变化后的节点内容
             */
            public void handleDataChange(String s, Object o) throws Exception {
                System.out.println(s+"服务器节点2内容被更新，更新的内容"+o);
                paths.put(s,o.toString());
            }

            /*
                当节点被删除时，会执行的回调方法
                s : path
             */
            public void handleDataDeleted(String s) throws Exception {
                System.out.println(s+"服务器节点2下线，断开服务器连接");
                paths.remove(s);
            }
        });

//        Thread.sleep(Integer.MAX_VALUE);

    }


    public static ConcurrentHashMap<String, String> getPaths() {
        return paths;
    }

    public static void setPaths(ConcurrentHashMap<String, String> paths) {
        ZkServerGeter.paths = paths;
    }

    /*public static void main(String[] args) throws InterruptedException {
        getZkServer();
    }*/
}
